#include "ListUtil.h"

ListUtil::ListUtil()
{
}

ListUtil::~ListUtil()
{
}

int ListUtil::getConditionKey(const char* operador)
{
	unsigned int retorno = OPERADOR_NULO;
	unsigned int sizeOperador = 0;

	if(operador != NULL)
	{
		sizeOperador = strlen(operador);
		if(sizeOperador == 1)
		{
			switch(operador[0])
			{
				case '=': retorno = OPERADOR_IGUAL; break;
				case '>': retorno = OPERADOR_MAYOR; break;
				case '<': retorno = OPERADOR_MENOR; break;
			};
		}
		else
		{
			if(sizeOperador == 2)
			{
				if(operador[0] == '!' && operador[1] == '=')
					retorno = OPERADOR_DISTINTO;
				else
					if(operador[0] == '>' && operador[1] == '=')
						retorno = OPERADOR_MAYOR_IGUAL;
					else
						if(operador[0] == '<' && operador[1] == '=')
							retorno = OPERADOR_MENOR_IGUAL;
			}
		}
	}
	return retorno;
}

void ListUtil::applyRangeFilter(ListPersistent &ls, OQLRangeCondition &cond){
	
	ListUtil::applyFilter(ls, *(OQLSimpleCondition*)cond.getCondition(0));
	ListUtil::applyFilter(ls, *(OQLSimpleCondition*)cond.getCondition(1));
}

void ListUtil::applyFilter(ListPersistent &ls, OQLSimpleCondition &cond){
	
	int op = ListUtil::getConditionKey(cond.getOperator().c_str());
	std::string valorCond = cond.getValue();
	bool isValid = false;
	//std::vector<int> lsErase;
	
	for(int i = 0; i < ls.getSize(); i++)
	{
		Persistent* object = ls.getPersistent(i);
		std::string valor = object->getValor(cond.getAttribute()[0].nombre); 
		double valorDouble = 0;
		bool isNumero = false;
		if (NumberUtil::isNumber(valor)==1){
			valorDouble = atof(valor.c_str());
			isNumero = true; 
		}
		isValid = false;
		switch(op)
		{
			case OPERADOR_MENOR:
			{
				if (isNumero){
					double valorDouCond = atof(valorCond.c_str());
					if (valorDouble < valorDouCond){
						isValid = true;
					}
				}else{
					if (valor < valorCond){
						isValid = true;
					}
				}
			}break;
			case OPERADOR_MENOR_IGUAL:
			{
				if (isNumero){
						double valorDouCond = atof(valorCond.c_str());
						if (valorDouble <= valorDouCond){
							isValid = true;
						}
					}else{
						if (valor <= valorCond){
							isValid = true;
						}
					}				
			}break;
			case OPERADOR_DISTINTO:
			{
				if (isNumero){
						double valorDouCond = atof(valorCond.c_str());
						if (valorDouble != valorDouCond){
							isValid = true;
						}
					}else{
						if (valor != valorCond){
							isValid = true;
						}
					}
			}break;
			case OPERADOR_MAYOR:
			{
				if (isNumero){
					double valorDouCond = atof(valorCond.c_str());
					if (valorDouble > valorDouCond){
						isValid = true;
					}
				}else{
					if (valor > valorCond){
						isValid = true;
					}
				}
			}break;
			case OPERADOR_MAYOR_IGUAL:
			{
				if (isNumero){
					double valorDouCond = atof(valorCond.c_str());
					if (valorDouble >= valorDouCond){
						isValid = true;
					}
				}else{
					if (valor >= valorCond){
						isValid = true;
					}
				}
			}break;
			case OPERADOR_IGUAL:
			{
				if (isNumero){
						double valorDouCond = atof(valorCond.c_str());
						if (valorDouble == valorDouCond){
							isValid = true;
						}
					}else{
						if (valor == valorCond){
							isValid = true;
						}
					}
			}break;
		};
		if (!isValid){
			// VERIFICAR QUE ESTA BORRANDO BIEN !!!!
			ls.erase(i);
			i = i - 1;
			//lsErase.push_back(i);
		}
	}
	
//	std::vector<int>::iterator it;
//	for (it = lsErase.begin(); it!=lsErase.end(); it++){
//		ls.erase(*it);
//	}
	
}

